/*
 * @Author: samples jadehh@live.com
 * @Date: 2023-12-14 11:03:04
 * @LastEditors: samples jadehh@live.com
 * @LastEditTime: 2023-12-14 11:03:04
 * @FilePath: /lib/ali_api.js
 * @Description: 阿里云盘Api
 */
import { _, jinja2 } from '../encodings/cat';
import * as Utils from '../index';
import { JadeLogging } from '../log';
import {
  Code,
  Drive,
  getHeader,
  getOAuthCache,
  getUserCache,
  Item,
  OAuth,
  post,
  postJson,
  Sub,
  User,
  CLIENT_ID,
} from './ali_object';

let quality = {},
  tempIds = [],
  shareToken = '',
  shareId = '',
  oauth = new OAuth(),
  user = new User(),
  driveInfo = new Drive(),
  tmpFolderName = 'TV',
  curTmpFolderFileId = '',
  JadeLog = new JadeLogging('阿里云盘', 'INFO');

async function initSome() {
  let user_cache_str = await getUserCache();
  user = User.objectFrom(user_cache_str);
  if (!_.isEmpty(user.getRefreshToken())) {
    await JadeLog.info('读取用户缓存成功', true);
  } else {
    await JadeLog.error('读取用户缓存失败', true);
  }

  let oauth_cache_str = await getOAuthCache();
  oauth = OAuth.objectFrom(oauth_cache_str);
  if (!_.isEmpty(oauth.getAccessToken())) {
    await JadeLog.info('读取授权成功', true);
  } else {
    await JadeLog.error('读取授权失败', true);
  }
  // quality = {
  //     "4K": "UHD", "2k": "QHD", "超清": "FHD", "高清": "HD", "标清": "SD", "流畅": "LD"
  // };
  quality = {
    '4K': 'UHD',
    '2k': 'QHD',
    超清: 'QHD',
    高清: 'HD',
    标清: 'SD',
    流畅: 'LD',
  };
  await JadeLog.info('阿里Api初始化完成');
}

async function getTempFileId() {
  curTmpFolderFileId = await createTmpFolder();
}

async function clearFile() {
  try {
    await deleteTmpFolderAndRecreate();
  } catch (e) {
    await JadeLog.error('清空缓存文件失败,失败原因为:{}' + e);
  }
  await cleanRecord();
}

async function cleanRecord() {
  await local.set('file', 'file_id', JSON.stringify({}));
}

async function setShareId(share_id) {
  getOAuthCache().length === 0 && (await oauth.clean().save());
  getUserCache().length === 0 && (await user.clean().save());
  shareId = share_id;
  return await refreshShareToken();
}

function getHeaderAuth(shareToken) {
  const params = {};
  params['x-share-token'] = shareToken;
  params['X-Canary'] = 'client=Android,app=adrive,version=v4.3.1';

  if (user.isAuthed()) {
    params.authorization = user.getAuthorization();
  }

  return params;
}

function getHeaderShare() {
  const params = getHeader();
  params['x-share-token'] = shareToken;
  params['X-Canary'] = 'client=Android,app=adrive,version=v4.3.1';
  return params;
}

function getHeaderOpen() {
  const params = {};
  params.authorization = oauth.getAuthorization();
  return params;
}

function aliExpection(data_str) {
  if (data_str.indexOf('TooManyRequests') > -1) {
    Utils.sleep(1);
    return { code: 429, content: data_str };
  } else if (data_str.indexOf('AccessTokenInvalid') > -1) {
    return { code: 400, content: data_str };
  } else if (data_str.indexOf('AccessTokenExpired') > -1) {
    return { code: 401, content: data_str };
  } else if (data_str.indexOf('BadRequest') > -1) {
    return { code: 402, content: data_str };
  } else if (data_str.indexOf('NotFound.File') > -1 || data_str.indexOf('ForbiddenFileInTheRecycleBin') > -1) {
    return { code: 403, content: data_str };
  } else if (data_str.indexOf('user not allowed access drive') > -1) {
    return { code: 404, content: data_str };
  } else if (data_str.indexOf('ForbiddenNoPermission.File') > -1) {
    return { code: 500, content: data_str };
  } else if (data_str.indexOf('InvalidParameter.ToParentFileId') > -1) {
    return { code: 501, content: data_str };
  } else if (data_str.indexOf('NotFound.ParentFileId') > -1) {
    return { code: 502, content: data_str };
  } else if (data_str.indexOf('The resource drive has exceeded the limit. File size exceeded drive capacity') > -1) {
    return { code: 503, content: data_str };
  } else if (data_str.indexOf('The resource drive has exceeded the limit. File size exceeded drive capacity') > -1) {
    return { code: 503, content: data_str };
  }
  return { code: 200, content: data_str };
}

async function alistManyRequest(data_str) {
  if (!(data_str.indexOf('Too Many Requests') > -1)) {
    return false;
  }
  await oauth.clean().save();
  return true;
}

// Alist Token获取
async function alist(url_param, params) {
  let url = 'https://api-cf.nn.ci/alist/ali_open/' + url_param;
  let response = await postJson(url, params, getHeader()),
    response_content = response.content;
  if (await alistManyRequest(response_content)) {
    await JadeLog.error(`Alist授权Token失败,失败原因为:太多请求,失败详情为:${response_content}`);
    return false;
  }
  oauth = await OAuth.objectFrom(response_content).save();
  return true;
}

// 阿里云盘用户Api
async function auth(url, params, shareToken, retry) {
  url = url.startsWith('https') ? url : 'https://api.aliyundrive.com/' + url;
  let response = await postJson(url, params, getHeaderAuth(shareToken));
  await JadeLog.debug(`正在请求需要阿里登录的url:${url},参数为:${JSON.stringify(params)}`);
  response = aliExpection(response.content);
  if (retry && response.code === 400) {
    await JadeLog.error('登录阿里云盘失败,失败原因为:登录Token无效,准备重新授权,失败详情:' + response.content);
    await refreshAccessToken('');
    return await auth(url, params, shareToken, false);
  }
  await JadeLog.debug(
    `完成请求需要阿里登录的url:${url},参数为:${JSON.stringify(params)},请求结果为${response.content}`,
  );
  return response.content;
}

// 需要授权的Api
async function oauthFunc(url, params, retry) {
  url = url.startsWith('https') ? url : 'https://open.aliyundrive.com/adrive/v1.0/' + url;
  await JadeLog.debug(`正在请求需要阿里授权的url:${url},参数为:${JSON.stringify(params)}`);
  let open_header = getHeaderOpen();
  let response = await postJson(url, params, open_header);
  response = aliExpection(response.content);
  if (
    retry &&
    (response.code === 400 ||
      response.code === 401 ||
      response.code === 429 ||
      response.code === 402 ||
      response.code === 403 ||
      response.code === 404)
  ) {
    if (response.code === 400) {
      await JadeLog.error('阿里授权失败,失败原因为:授权Token无效,准备重新授权,失败详情:' + response.content);
      await activateRefreshOpenToken();
    } else if (response.code === 401) {
      await JadeLog.error('阿里授权失败,失败原因为:授权Token失效,准备重新授权,失败详情:' + response.content);
      await activateRefreshOpenToken();
    } else if (response.code === 402) {
      await JadeLog.error('阿里授权失败,失败原因为:授权Token失效,准备重新授权,失败详情:' + response.content);
      return await oauthFunc(url, params, true);
    } else if (response.code === 403) {
      await JadeLog.error('阿里授权失败,失败原因为:没有找到缓存文件,失败详情:' + response.content);
      await cleanRecord();
      return 'retry';
    } else if (response.code === 404) {
      await JadeLog.error('阿里授权失败,失败原因为:用户没有权限' + response.content);
      return await oauthFunc(url, params, true);
    } else if (response.code === 429) {
      await JadeLog.error(`正在请求需要阿里授权的url:${url},请求过于频繁,稍后重试,10分钟后再重试`);
      Utils.sleep(10 * 60);
      return await oauthFunc(url, params, true);
    }
    return await oauthFunc(url, params, false);
  }
  await JadeLog.debug(
    `完成请求需要阿里授权的url:${url},参数为:${JSON.stringify(params)},请求结果为:${JSON.stringify(response)}`,
  );
  return response.content;
}

async function shareFunc(url, params) {
  url = url.startsWith('https') ? url : 'https://api.aliyundrive.com/' + url;
  let headers = getHeaderShare(),
    response = await postJson(url, params, headers);
  return response.content;
}

//主动刷新授权Token

async function activateRefreshOpenToken() {
  await oauth.clean().save();
  await refreshOpenToken();
}

async function refreshShareToken() {
  try {
    let params = {};
    params.share_id = shareId;
    params.share_pwd = '';
    let response_content = await post('v2/share_link/get_share_token', params),
      response_json = JSON.parse(response_content);
    if (response_json['code'] === 'ShareLink.Cancelled') {
      await JadeLog.error('分享链接被取消了');
    }
    shareToken = response_json.share_token;
    return shareToken;
  } catch (e) {
    await JadeLog.error('刷新Share Token失败' + e);
  }
}

//支持切换Token
async function refreshAccessToken(token) {
  try {
    if (_.isEmpty(user.getAccessToken()) || user.getRefreshToken() !== token) {
      let refresh_token_params = {};
      refresh_token_params.refresh_token = user.getRefreshToken();
      refresh_token_params.grant_type = 'refresh_token';
      await JadeLog.info(`准备登录阿里云盘,登录Token为:${user.getRefreshToken()}`);
      let response_conetent = await post('https://auth.aliyundrive.com/v2/account/token', refresh_token_params);
      if (response_conetent.indexOf('InvalidParameter.RefreshToken') > 1 || _.isEmpty(response_conetent)) {
        if (_.isEmpty(response_conetent)) {
          await JadeLog.error(`登录阿里云盘失败,登录Token为:${user.getRefreshToken()},失败原因为:检查Token是否正确`);
        } else {
          await JadeLog.error(
            `登录阿里云盘失败,登录Token为:${user.getRefreshToken()},失败原因为:检查Token是否正确,返回结果为:${response_conetent}`,
          );
        }
      } else {
        await JadeLog.info(`登录阿里云盘成功,登录Token为:${user.getRefreshToken()}`);
        user = await User.objectFrom(response_conetent).save();
      }
    } else {
      await JadeLog.info(`阿里云盘已登录,无需重复登录,登录Token为:${user.getRefreshToken()}`);
    }
    return true;
  } catch (e) {
    await JadeLog.error(`登录阿里云盘失败,登录Token为:${user.getRefreshToken()},失败原因为:${e}`);
    await user.clean().save();
    return true;
  }
}

async function oauthRequest() {
  try {
    let params = {};
    params.authorize = 1;
    params.scope = 'user:base,file:all:read,file:all:write';
    let url =
      'https://open.aliyundrive.com/oauth/users/authorize?client_id=' +
      CLIENT_ID +
      '&redirect_uri=https://alist.nn.ci/tool/aliyundrive/callback&scope=user:base,file:all:read,file:all:write&state=';
    await JadeLog.debug(`正在请求获取阿里授权码的url:${url},参数为:${params}`);
    let response_str = await auth(url, params, shareToken, true);
    await JadeLog.debug(`完成请求获取阿里授权码的url:${url},参数为:${params},返回值为:${response_str}`);
    if (_.isEmpty(response_str) || response_str.indexOf('AccessTokenInvalid') > -1) {
      if (_.isEmpty(response_str)) {
        await JadeLog.error(`请求获取阿里授权码失败,失败原因为:还未登录`);
      } else {
        await JadeLog.error(`请求获取阿里授权码失败,失败原因为:还未登录,失败详情为:${response_str}`);
      }
    } else {
      await JadeLog.info(`请求获取阿里授权码成功,返回值为:${response_str}`);
      return await oauthRedirect(Code.objectFrom(response_str).getCode());
    }
  } catch (e) {
    await JadeLog.error(`请求获取阿里授权失败,失败原因为:${e}`);
    return false;
  }
}

async function oauthRedirect(code) {
  try {
    let params = {};
    params.code = code;
    params.grant_type = 'authorization_code';
    return await alist('code', params);
  } catch (e) {
    // // console.debug(_0x114c46);
    await oauth.clean().save();
    return false;
  }
}

async function refreshOpenToken() {
  try {
    // 刷新 Refresh Token
    if (_.isEmpty(oauth.getRefreshToken())) {
      return await oauthRequest();
    }
    // 刷新Access Token
    if (_.isEmpty(oauth.getAccessToken())) {
      let params = {};
      params.grant_type = 'refresh_token';
      params.refresh_token = oauth.getRefreshToken();
      return await alist('token', params);
    }
    return true;
  } catch (e) {
    await JadeLog.error('刷新授权Token失败,失败原因为:' + e);
    await oauth.clean().save();
    return false;
  }
}

async function getFileByShare(index, share_token, share_url, video_item_list, sub_item_list) {
  let params = {};
  params.share_id = shareId;
  let file_id = share_url.split('folder/').slice(-1)[0];
  if (file_id.length !== 40) {
    file_id = '';
  }
  let response_str = await post('adrive/v3/share_link/get_share_by_anonymous', params),
    response_json = JSON.parse(response_str),
    item_file_id = getParentFileId(file_id, response_json),
    item = new Item(item_file_id);
  await listFiles(index, item, video_item_list, sub_item_list, share_token);
}

async function listFiles(index, item, video_item_list, sub_item_list, share_token) {
  return await listFilesMarker(index, item, video_item_list, sub_item_list, '', share_token);
}

async function listFilesMarker(index, item, video_item_list, sub_item_list, netxt_markers, share_token) {
  let new_item = {},
    file_list = [];
  new_item.limit = 200;
  new_item.share_id = shareId;
  new_item.share_token = share_token;
  new_item.parent_file_id = item.getFileId();
  new_item.order_by = 'name';
  new_item.order_direction = 'ASC';
  new_item.share_index = index;
  if (netxt_markers.length > 0) {
    new_item.marker = netxt_markers;
  }
  let items = Item.objectFrom(await shareFunc('adrive/v2/file/list_by_share', new_item), shareToken, index);
  for (const r_item of items.getItems()) {
    if (r_item.getType() === 'folder') {
      file_list.push(r_item);
    } else {
      if (r_item.getCategory() === 'video' || r_item.getCategory() === 'audio') {
        //判断数组中是否有file_id
        //
        let is_video_file_exists = false;
        for (const video_item of video_item_list) {
          if (r_item.getFileId() === video_item.getFileId()) {
            is_video_file_exists = true;
            await JadeLog.debug('视频分享文件重复,无需添加');
          }
        }
        if (!is_video_file_exists) {
          if (r_item.getCategory() === 'video' && r_item.size / 1000000 > 10) {
            video_item_list.push(r_item.parentFunc(item.getName()));
          }
        }
      } else {
        if (Utils.isSub(r_item.getExt())) {
          let is_sub_file_exists = false;
          for (const sub_item of sub_item_list) {
            if (r_item.getFileId() === sub_item.getFileId()) {
              is_sub_file_exists = true;
              await JadeLog.debug('字幕分享文件重复,无需添加');
            }
          }
          if (!is_sub_file_exists) {
            sub_item_list.push(r_item);
          }
        }
      }
    }
  }
  items.getNextMarker().length > 0 &&
    (await listFilesMarker(index, item, video_item_list, sub_item_list, items.getNextMarker()));
  for (const file of file_list) {
    await listFiles(index, file, video_item_list, sub_item_list);
  }
}

function getParentFileId(file_id, items) {
  let file_infos = items.file_infos;

  if (!_.isEmpty(file_id)) {
    return file_id;
  }

  if (file_infos.length === 0) {
    return '';
  }

  let item = file_infos[0];

  if (item.type === 'folder') {
    return item.file_id;
  }
  if (item.type === 'file' && item.category === 'video') {
    return 'root';
  }
  return '';
}

async function getSubs(sub_list, share_id) {
  let sub_url_list = [];
  for (const sub_str of sub_list) {
    if (!(sub_str.indexOf('@@@') > -1)) {
      continue;
    }
    let sub_split_list = sub_str.split('@@@'),
      sub_name = sub_split_list[0],
      sub_ext = sub_split_list[1],
      sub_file_id = sub_split_list[2],
      sub_url = await getDownloadUrl(sub_file_id, share_id);

    sub_url_list.push(Sub.create().setName(sub_name).setExt(sub_ext).setUrl(sub_url));
  }
  return sub_url_list;
}

async function getDriveInfo() {
  if (!_.isEmpty(driveInfo) && !_.isEmpty(driveInfo.default_drive_id)) {
    return driveInfo;
  }

  let _0x3740f3 = await oauthFunc('user/getDriveInfo', {}, true),
    _0x56fde5 = JSON.parse(_0x3740f3);

  driveInfo = {
    default_drive_id: _0x56fde5.default_drive_id,
    resource_drive_id: _0x56fde5.resource_drive_id,
    backup_drive_id: _0x56fde5.backup_drive_id,
  };
  return driveInfo;
}

async function getDriveId() {
  if (_.isEmpty(user.getDriveId())) {
    let drive = await getDriveInfo();
    return drive.resource_drive_id;
  }
  return user.getDriveId();
}

async function getDownloadUrl(file_id, share_id, share_token) {
  let drive_id = await getDriveId();
  tempIds.unshift(await copy(file_id, share_id, share_token));
  let params = {};
  params.file_id = tempIds[0];
  params.drive_id = drive_id;
  if (tempIds[0] !== null) {
    let response_str = await oauthFunc('openFile/getDownloadUrl', params, true);
    if (response_str === 'retry') {
      await JadeLog.info('尝试重新获取下载链接');
      return await getDownloadUrl(file_id, share_id);
    } else {
      await JadeLog.info('获取下载链接成功:返回结果为:' + response_str + '请求参数为:' + JSON.stringify(params));
      return JSON.parse(response_str).url;
    }
  } else {
    await JadeLog.error('获取下载链接失败:失败原因:请检查转存文件失败原因');
    return null;
  }
}

async function getVideoPreviewPlayInfo(file_id, share_id, shareToken) {
  let drive_id = await getDriveId();
  tempIds.unshift(await copy(file_id, share_id, shareToken));
  let params = {};
  params.file_id = tempIds[0];
  params.drive_id = drive_id;
  params.category = 'live_transcoding';
  params.url_expire_sec = '14400';
  let response_str = await oauthFunc('openFile/getVideoPreviewPlayInfo', params, true);
  return JSON.parse(response_str).video_preview_play_info;
}

async function playerContent(file_id, share_id, share_token) {
  try {
    await JadeLog.info('正在获取原画的播放地址和字幕下载链接', true);
    let download_url = await getDownloadUrl(file_id, share_id, share_token);
    // let sub_list = await getSubs(file_id_list,share_id);
    await JadeLog.info('获取原画的播放地址和字幕下载链接成功', true);
    await JadeLog.info(`下载地址为:${download_url}`);
    return download_url;
  } catch (e) {
    await JadeLog.error('获取原画的播放地址和字幕下载链接失败:失败原因为:' + e);
  }
}

// 转码头的Url和字幕
async function playerContentByFlag(file_id, flag, share_id, shareToken) {
  try {
    await JadeLog.info('正在获取转码后的播放地址和字幕下载链接', true);
    let video_preview_play_info = await getVideoPreviewPlayInfo(file_id, share_id, shareToken),
      video_preview_url = getPreviewUrl(video_preview_play_info, flag);
    // let sub_list = await getSubs(file_id_list,share_id),
    //     sub_p_list = getSubsByPlayInfo(video_preview_play_info);

    // for (const sub_p of sub_p_list) {
    //     sub_list.push(sub_p);
    // }

    await JadeLog.info('获取转码后的播放地址和字幕下载链接成功', true);
    await JadeLog.info(`下载地址为:${video_preview_url}`);
    return video_preview_url;
  } catch (e) {
    await JadeLog.error(`获取转码后的播放地址和字幕下载链接失败,失败原因为:${e}`);
  }
}

function getPreviewUrl(video_preview_play_info, flag) {
  if (!video_preview_play_info.hasOwnProperty('live_transcoding_task_list')) {
    return '';
  }
  let live_transcoding_task_list = video_preview_play_info.live_transcoding_task_list;
  for (let index = 0; index < live_transcoding_task_list.length; ++index) {
    let live_transcoding_task = live_transcoding_task_list[index];

    if (live_transcoding_task.template_id === quality[flag]) {
      return live_transcoding_task.url;
    }
  }
  return live_transcoding_task_list.slice(-1)[0].url;
}

function getSubsByPlayInfo(video_preview_play_info) {
  if (!video_preview_play_info.hasOwnProperty('live_transcoding_subtitle_task_list')) {
    return [];
  }
  let live_transcoding_subtitle_task_list = video_preview_play_info.live_transcoding_subtitle_task_list,
    sub_p_list = [];
  for (let index = 0; index < live_transcoding_subtitle_task_list.length; ++index) {
    let live_transcoding_subtitle_task = live_transcoding_subtitle_task_list[index],
      language = live_transcoding_subtitle_task.language,
      url = live_transcoding_subtitle_task.url;
    sub_p_list.push(Sub.create().setUrl(url).setName(language).setLang(language).setExt('vtt'));
  }
  return sub_p_list;
}

async function copy(file_id, shareId, shareToken) {
  let copy_file_id;
  let cache_dic = {};
  try {
    cache_dic = JSON.parse(await local.get('file', 'file_id'));
  } catch (e) {}
  copy_file_id = cache_dic[file_id];
  if (typeof copy_file_id == 'string') {
    await JadeLog.info(`file id为:${file_id},已经缓存过,copy file id为:${copy_file_id}`);
  } else {
    let params_str =
        '{"requests":[{"body":{"file_id":"{{data.fileId}}","share_id":"{{data.shareId}}","auto_rename":true,"to_parent_file_id":"{{data.tmpFolderFileId}}","to_drive_id":"{{data.driveId}}"},"headers":{"Content-Type":"application/json"},"id":"0","method":"POST","url":"/file/copy"}],"resource":"file"}',
      drive_id = await getDriveId(),
      params = {
        fileId: file_id,
        shareId: shareId,
        driveId: drive_id,
        tmpFolderFileId: curTmpFolderFileId,
      };
    params_str = jinja2(params_str, {
      data: params,
    });
    await JadeLog.debug(`正在转存文件,文件id为:${file_id}`, true);
    let response_str = await auth('adrive/v2/batch', JSON.parse(params_str), shareToken, true);
    let response = aliExpection(response_str);
    if (
      response.code === 500 ||
      response.code === 501 ||
      response.code === 502 ||
      response.code === 503 ||
      response.code === 403
    ) {
      if (response.code === 500) {
        await JadeLog.error('转存文件失败,失败详情:' + response.content);
        return copy(file_id);
      } else if (response.code === 501) {
        await JadeLog.error('转存文件失败,失败详情:' + response.content);
        return copy(file_id);
      } else if (response.code === 502) {
        await JadeLog.error('转存文件失败,失败原因为:转存文件夹不存在,失败详情:' + response.content);
        return null;
      } else if (response.code === 503) {
        await JadeLog.error('转存文件失败,失败原因为:转存文件夹大小被限制' + response.content);
        await clearFile();
        return copy(file_id);
      } else if (response.code === 403) {
        await JadeLog.error('转存文件失败,失败原因为:没有找到File Id,失败详情:' + response.content);
        return null;
      }
    }
    await JadeLog.debug(`转存文件成功,文件id为:${file_id},请求结果为:${response_str}`);
    copy_file_id = JSON.parse(response_str).responses[0].body.file_id;
    let file_dic = {};
    try {
      JSON.parse(await local.get('file', 'file_id'));
    } catch (e) {}
    file_dic[file_id] = copy_file_id;
    await local.set('file', 'file_id', JSON.stringify(file_dic));
  }
  return copy_file_id;
}

async function deleteTmpFolderAndRecreate() {
  // 删除缓存文件夹
  let file_id = await tmpFolderExistsFunc();
  file_id && (await trashFile(file_id), await recyclebinClear());
  await getTempFileId();
}

//放入回车站
async function trashFile(file_id) {
  let params_str =
      '{"requests":[{"body":{"file_id":"{{data.fileId}}","drive_id":"{{data.driveId}}"},"headers":{"Content-Type":"application/json"},"id":"0","method":"POST","url":"/recyclebin/trash"}],"resource":"file"}',
    drive_id = await getDriveId(),
    params = {
      fileId: file_id,
      driveId: drive_id,
    };
  params_str = jinja2(params_str, {
    data: params,
  });
  await JadeLog.debug(`正在准备删除文件,文件id为:${file_id}`, true);
  let response = await auth('v2/batch', JSON.parse(params_str), shareToken, true);
  await JadeLog.debug(`删除文件成功,文件id为:${file_id},请求结果为:${response}`);
  return true;
}

//清空回车站
async function recyclebinClear() {
  let drive_id = await getDriveId(),
    params = {
      drive_id: drive_id,
    };
  await auth('v2/recyclebin/clear', params, shareToken, true);
  await JadeLog.info('清空回车站成功', true);
  return true;
}

async function createTmpFolder() {
  //创建文件夹
  let file_id = await tmpFolderExistsFunc();
  if (file_id) {
    await JadeLog.info('文件夹存在,无需重新创建');
    return file_id;
  }
  await JadeLog.debug('文件夹不存在,重新创建文件夹');
  let drive_id = await getDriveId(),
    params = {
      check_name_mode: 'refuse',
      drive_id: drive_id,
      name: tmpFolderName,
      parent_file_id: 'root',
      type: 'folder',
    },
    response_str = await oauthFunc('openFile/create', params, true);
  let response_json = JSON.parse(response_str);
  if (_.isEmpty(response_json.drive_id)) {
    await JadeLog.error(`创建文件夹失败,失败原因为:${response_str}`);
    return null;
  }
  await JadeLog.info(`创建文件夹成功`, true);
  return response_json.file_id;
}

async function tmpFolderExistsFunc() {
  let drive_id = await getDriveId(),
    params = {
      drive_id: drive_id,
      parent_file_id: 'root',
      limit: 100,
      order_by: 'updated_at',
      order_direction: 'DESC',
    },
    response_str = await oauthFunc('openFile/list', params, true);
  let response_json = JSON.parse(response_str);
  if (_.isEmpty(response_json.items)) {
    return false;
  }
  for (const item of response_json.items) {
    if (item.name === tmpFolderName) {
      return item.file_id;
    }
  }
  return false;
}

async function setToken(token) {
  // Token设置
  user.setRefreshToken(token);
  await refreshAccessToken(token);
  await refreshOpenToken();
}

export { initSome, setToken, clearFile, setShareId, getFileByShare, playerContent, playerContentByFlag, getTempFileId };
